GtkListBox: Convert to indirect rendering

Note that there is a problem with the pixel cache that causes
listboxes to come out black when in a scrolled window.

gadget: Fix handling of custom content

The transformations here were wrong, causing content to go nowhere.
This patch fixes check and radio buttons to appear as expected.

GtkCheckButton: Convert to indirect rendering

This is another example of indirect rendering with a box gadget.
There is currently still some positioning problem with the
checkmark.

Prevent box gadget content from being drawn twice

Now that we split out box gadget children into separate
render nodes, we must not draw them onto the box gadgets
node anymore.

GtkExpander: Convert to indirect rendering

This is the first example of indirect rendering involving
a box gadget. For now, we iterate the child gadgets manually,
and rely on gtk_container_propagate_render_node for the
child widgets. Eventually, we may want a better solution
here.

gadget: Add a has_content vfunc

...and implement it for GtkCssGadget and GtkCssCustomGadget.
This allows us to decide on a per-object basis if a custom
gadget needs a render node for content or not.

button: Restore focus

The custom gadget draw function has the side effect of informing
the gadget machinery wether to draw focus or not. Bring the
draw function back, just for its boolean return value. We may
want to find a better solution for this.

Allow selective debug spew

I don't think this should stay in the code long-term, but it
is useful for debugging. It helped me track down some suspicious
placements of render nodes.

Add details to css render nodes

Give all nodes the same detail about the owner widget.
This reveals that every GtkCssCustomGadget gets a
DrawGadgetContents node, even if their draw_func is NULL.
We may want to come up with a better solution for that.

Some debug help

Make the bounds of drawing surfaces created by render nodes visible.

Trigger with GSK_DEBUG=surface.

Drop an unused variable

gtk: Clean up render fallback node creation in GtkWidget

gtk: Port GtkHeaderBar to render nodes

gtk: Port GtkActionBar to render nodes

gtk: Attempt at handling CSS coordinates

When creating the GskRenderNodes for the gadgets we should not translate
the coordinates inside the Cairo context, but we should tweak the
coordinates of the anchor point.

This is still not enough to get an appropriate rendering, as the result
is still slightly offset to the left.

gsk: Pass the appropriate value for the n_quads argument

Instead of passing the size of the buffer, we should pass the number of
quads; we know what the size of a single quad structure is, so we can do
the multiplication internally when creating the VAO.

This allows us to print the quads for debugging purposes.

GtkFrame: Convert to indirect rendering

Create a GskRenderNode for the contents of the frame.

gtk: Add convenience function for creating render nodes

GtkWidget.create_render_node() sets up a GskRenderNode appropriate for
rendering the contents of a widget, including its bounds,
transformation, and anchor point.

gsk: Rename set_offset() to set_anchor_point()

The naming is consistent with other scene graph libraries, as it
represents an additional translation transformation applied on top of
the provided transformation matrices.

We can also simplify the implementation by applying the translation when
we compute the world matrix.

gsk: Recycle textures across frames

We keep the textures used inside a frame around until the end of the
following frame; whenever we need a texture with the same size, and
it's not marked in use, then we just reuse the existing texture.

Fix fallback render nodes

We were allocating a surface thats big enough for the clip, and
we were setting the transform for that, but then GtkContainer
was overriding the transform with the one for the allocation.
Also, we were drawing at the clip position, not the allocation
position.

Add an offset to render nodes

This will let us account for the difference between
clip and allocation.

gsk: Split of debug spew for transforms

This was overwhelming other useful debug output, so make it
opt-in. We print the render items for both opengl and transforms,
since the matrices bleed into each other, otherwise.

gsk: Add debug macros that trigger on two conditions

This will be useful in the following commits.

gsk: Add a debug flag for transforms

gsk: Improve debug output a bit

Indent render node debug spew to make the tree structure obvious.

button: Convert to indirect rendering

WARNING! This commit breaks GtkButton subclasses.

Convert GtkGrid to indirect rendering

Following the example of GtkBox.

gsk: Add GskProfiler to GskRenderer

The profiler instance is per-renderer, and is accesible to
implementations.

gsk: Add profiler object

The GskProfiler holds counters and timers, and will be used by the
renderer implementations to acquire frame timings.

box: Port from immediate to deferred rendering

Drop the ::draw() vfunc implementation in favour of the
::get_render_node() vfunc.

Integrate CSS gadget with GSK render nodes

First stab at an internal API that generates render nodes when drawing a
CSS gadget.

gtk: Update the coordinates when propagating render nodes

Just like gtk_container_propagate_draw() does for the immediate mode
rendering.

Use the projection to flip around the content

Since we use an FBO to render the contents of the render node tree, the
coordinate space is going to be flipped in GL. We can undo the flip by
using an appropriate projection matrix, instead of changing the sampling
coordinates in the shaders and updating all our coordinates at render
time.

widget: Fix compatibility fallbacks

gsk: Add texture size to debug message

gsk: Take into account the scaling factor

We need to apply a scaling factor whenever we deal with user-supplied
coordinates, like:

 - when creating textures
 - when setting up the viewport
 - when submitting the scene

gsk: Tie render nodes to renderers

Render nodes need access to rendering information like scaling factors.
If we keep render nodes separate from renderers until we submit a nodes
tree for rendering we're going to have to duplicate all that information
in a way that makes the API more complicated and fuzzier on its
semantics.

By having GskRenderer create GskRenderNode instances we can tie nodes
and renderers together; since higher layers will also have access to
the renderer instance, this does not add any burden to callers.

Additionally, if memory measurements indicate that we are spending too
much time in the allocation of new render nodes, we can now easily
implement a free-list or a renderer-specific allocator without breaking
the API.

gsk: Bind GL context to the GL profiler

Similarly to how we bind it to the GL driver object used by the GSK GL
renderer.

gtk: Port GtkWindow to render nodes

WARNING: BROKEN COMMIT

gtk: Add GtkContainer API to gather render nodes

We cannot implement GtkWidgetClass.get_render_node() in GtkContainer
without breaking the fallback path that renders a widget to a single
render node rasterization. For GtkContainer subclasses we should provide
a simple API, similar to gtk_container_propagate_draw(), that gathers
all the render nodes for each child.

gtk: Name GSK render nodes

For debugging purposes it's helpful to name the nodes.

gsk: Fix build without Wayland

gsk: Add redirection to FBOs for opacity groups

If a node is non-opaque and has a non-zero opacity we need to paint its
contents and children first to an off screen buffer, and then render the
resulting texture at the desired opacity — otherwise the opacities will
combine and result in the wrong rendering.

gsk: Drop opaque/transparent item split

We're not going to use separate rendering lists soon, and the way we
render items is less similar to a gaming engine and more similar to a
simpler compositor. This means we don't need to perform a two pass
rendering — opaque items first, transparent items later.

gsk: Rename uniforms and attributes in shaders

Use appropriate names, and annotate the names with the types — 'u' for
uniforms, 'a' for attributes. The common preambles for shaders are split
from the bodies, so we need some way to distinguish the uniforms and the
attributes just from their name.

gsk: Move resource handling inside GskGLDriver

We want the GL driver to cache as many resources as possible, so we can
always ensure that we're in a consistent state, and we can handle state
transitions more appropriately.

gsk: Simplify buffer handling in GskGLRenderer

We don't have optional stencil and depth buffers, like GtkGLArea: we
always create both of them internally.

gsk: Drop render buffer code path from GskGLRenderer

We always use texturing, to preserve the alpha channel when blitting the
frame buffer object on the window surface.

gsk: Rework surface -> texture API

Drop the texture parameters handling from the texture creation, and
associate them with the contents upload. Also, rename the function to
something more in line with what it does.

gsk: Add GL driver API to create render targets

It's going to be used by the GL renderer to safely create and bind
FBOs when needed.

gsk: Turn texture cache into a hash table

We want to add the list of FBOs tied to a texture; this means we cannot
trivally copy the Texture structure when adding it to a GArray. We're
also going to have more textures than VAOs, so it makes more sense to
use a O(1) access data structure for them.

gsk: Add GL profiler

We can use the GL_ARB_timer_query extension (available since OpenGL
3.2, and part of the OpenGL specification since version 3.3) to query
the time elapsed when drawing each frame. This allows us to gather
timing information on our use of the GPU.

gsk: Split surface upload from texture creation

We're going to need a method to create textures without a surface.

gsk: Enable depth testing

Use the appropriate depth testing function for transparent items.

gsk: Use consistent naming for blend fragment shader

This should make it immediately clear if we're doing something wrong.

gsk: Fix pre-condition check

We warn if the node is marked as not mutable.

gsk: Flip mutability on GskRenderNode.finalize

We use the public API when removing children nodes, so we need to mark
the node as mutable while we destroy it.

gsk: Add specific debug type for shaders

So that we don't lose GskShaderBuilder debugging messages in the stream
of GskGLRenderer ones.

gsk: Add GskGLDriver

We can move the caching and management of textures, VAOs, and state of
the GL machinery into a single object, GskGLDriver.

gsk: Use the right pointer to the parent RenderItem

We copy the local RenderItem into the render items array, so we need to
use the copy in the array in order to get the correct reference.

Ensure that render nodes are translated

The clip rectangle may have non-zero offsets, so we need to ensure that
the GskRenderNode associated to the rendered area is translated by those
same offsets.

gsk: Add fundamental type annotations for GskRenderNode

We need to annotate the GskRenderNode so that the introspection
machinery can find the functions for managing reference counting
and GValues.

gsk: Add 'blit' program

For the root node we do not need to use blending, as it does not have
any backdrop to blend into. We can use a simpler 'blit' program that
only takes the content of the source and fills the texture quad with
it.

gsk: Consolidate program creation and storage

We should use ShaderBuilder to create and store programs for the GL
renderer. This allows us to simplify the creation of programs (by moving
the compilation phase into the ShaderBuilder::create_program() method),
and move towards the ability to create multiple programs and just keep a
reference to the program id.

docs: Add more GSK documentation

gsk: Add more modes to the blend shader

Use the compositing CSS spec at:

  https://www.w3.org/TR/compositing-1/#blending

For the implementation.

gsk: Don't store the uniform and attribute location twice

We should keep the ShaderBuilder around and use it to query the various
uniform and attribute locations when needed, instead of storing those
offsets into the Renderer instance, and copying them. This allows a bit
more flexibility, once we have more than one program built into the
renderer.

gsk: Add getter for program id in ShaderBuilder

Since we store it into the ShaderBuilder instance we should also allow
getting the program id.

gsk: Add debugging notes to ShaderBuilder

Print out the generated shader and the list of available uniforms and
attributes.

gsk: Rework how GLSL shaders are built

The GL renderer should build the GLSL shaders using GskShaderBuilder.
This allows us to separate the common parts into separate files, and
assemble them as necessary, instead of shipping one big shader per type
of GL API (GL3, GL legacy, and GLES).

gsk: Add ShaderBuilder

GskShaderBuilder is an ancillary, private type that deals with the
internals of taking GLSL shaders from resources and building them,
with the additional feature of being able to compose shaders from a
common preamble, as well as adding conditional defines (useful for
enabling debugging code in the shaders themselves).

gsk: Add rendering debug mode for shaders

It's going to be useful to inject debugging data into the shaders used
by GSK.

gdk: Add more GDK_GL_ERROR error ids

We're going to use them in other locations.

gsk: Use the node's blend mode in the GL renderer

gsk: Store blend mode in the render node

gsk: Make GskBlendMode enumeration public

gsk: Allow sampling between parent and child nodes

gsk: Group render state attributes

gsk: Turn GskRenderNode into a pure GTypeInstance

Using GObject as the base type for a transient tree may prove to be too
intensive, especially when creating a lot of node instances. Since we
don't need properties or signals, and we don't need complex destruction
semantics, we can use GTypeInstance directly as the base type for
GskRenderNode.

gtk: Use GskRenderNode to render widgets

We need a virtual function to retrieve the GskRenderNode for each
widget, which is supposed to attach its own children's GskRenderNodes.
Additionally, we want to maintain the existing GtkWidget::draw mechanism
for widgets that do not implement get_render_node() — as well as widgets
that have handlers connected to the ::draw signal.

gtk: Add a GskRenderer to GtkWindow

Each top-level should have its own GskRenderer, to be used when drawing
the render node tree.

gsk: Rework GskRenderer and GskRenderNode semantics

This commit changes the way GskRenderer and GskRenderNode interact and
are meant to be used.

GskRenderNode should represent a transient tree of rendering nodes,
which are submitted to the GskRenderer at render time; this allows the
renderer to take ownership of the render tree. Once the toolkit and
application code have finished assembling it, the render tree ownership
is transferred to the renderer.

gsk: Flush the GL render items cache

Whenever the render tree changes we want to drop the RenderItem arrays,
as each item contains a pointer to the GskRenderNode which becomes
dangling once the root node changed.

gsk: Add GskRenderer::clear_tree

We need a way to clear eventual caches inside GskRenderer subclasses if
the root node has changed.

gsk: Port GskGLRenderer to GLES

Use the appropriate API and shaders if the GdkGLContext was created for
OpenGL ES instead of OpenGL.

gsk: Use surface-to-texture utility function

Now that we have it.

gsk: Rename shaders for OpenGL

gdk: Add utility for uploading Cairo surfaces to GL

The surface-to-GL upload logic has become more complicated with the
addition of the GLES code paths; it's more logical to have a public
utility function that can be called from GDK users, instead of copy
pasting the whole thing multiple times.

build: Add GSK deps to GTK

Initial implementation of GSK rendering pipeline

GSK is conceptually split into two scene graphs:

 * a simple rendering tree of operations
 * a complex set of logical layers

The latter is built on the former, and adds convenience and high level
API for application developers.

The lower layer, though, is what gets transformed into the rendering
pipeline, as it's simple and thus can be transformed into appropriate
rendering commands with minimal state changes.

The lower layer is also suitable for reuse from more complex higher
layers, like the CSS machinery in GTK, without necessarily port those
layers to the GSK high level API.

This lower layer is based on GskRenderNode instances, which represent
the tree of rendering operations; and a GskRenderer instance, which
takes the render nodes and submits them (after potentially reordering
and transforming them to a more appropriate representation) to the
underlying graphic system.

gsk: Initial commit / build environment

label: Avoid shadowing variables

Update POTFILES.in

Add a test for cursor names

This tests both that all standard cusor yield a cursor, and that
unknown cursor names yield NULL.

x11: Add the same message as the wayland backend has

This seems prudent, if we make noise about missing cursors
on Wayland, we should do the same on X11.

Reduce a warning to a message

The warning interferes with having a testcase to check this behavior,
so reduce this to a message.

Remove GtkAction

Remove GtkActionGroup

Fix unittests